const tagService = require('../services/tag.service');
const cacheService = require('../services/cache.service');
const { success, error } = require('../utils/response');

/**
 * 获取标签列表
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @param {Function} next - 下一个中间件
 */
exports.getAllTags = async (req, res, next) => {
  try {
    const { search } = req.query;
    
    // 构建缓存键
    const cacheKey = `tags:list:${search || 'all'}`;
    
    // 尝试从缓存获取，如果没有则从数据库获取并缓存
    const tags = await cacheService.getOrSet(cacheKey, async () => {
      const options = {};
      
      // 添加搜索条件
      if (search) {
        options.search = search;
      }
      
      return await tagService.findAll(options);
    }, 600); // 缓存10分钟
    
    res.json(success(tags, '获取标签列表成功'));
  } catch (err) {
    next(err);
  }
};

/**
 * 获取单个标签
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @param {Function} next - 下一个中间件
 */
exports.getTagById = async (req, res, next) => {
  try {
    const { id } = req.params;
    
    // 构建缓存键
    const cacheKey = `tags:${id}`;
    
    // 尝试从缓存获取，如果没有则从数据库获取并缓存
    const tag = await cacheService.getOrSet(cacheKey, async () => {
      return await tagService.findById(id);
    }, 600); // 缓存10分钟
    
    if (!tag) {
      return res.status(404).json(error('标签不存在', 404));
    }
    
    res.json(success(tag, '获取标签成功'));
  } catch (err) {
    next(err);
  }
};

/**
 * 创建标签（管理员功能）
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @param {Function} next - 下一个中间件
 */
exports.createTag = async (req, res, next) => {
  try {
    const tagData = req.body;
    
    // 创建标签
    const tag = await tagService.create(tagData);
    
    // 清除标签列表缓存
    await cacheService.delByPattern('tags:list:*');
    
    res.status(201).json(success(tag, '标签创建成功', 201));
  } catch (err) {
    next(err);
  }
};

/**
 * 更新标签（管理员功能）
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @param {Function} next - 下一个中间件
 */
exports.updateTag = async (req, res, next) => {
  try {
    const { id } = req.params;
    const tagData = req.body;
    
    // 检查标签是否存在
    const existingTag = await tagService.findById(id);
    
    if (!existingTag) {
      return res.status(404).json(error('标签不存在', 404));
    }
    
    // 更新标签
    const updatedTag = await tagService.update(id, tagData);
    
    // 清除相关缓存
    await cacheService.del(`tags:${id}`);
    await cacheService.del(`tags:slug:${existingTag.slug}`);
    if (tagData.slug && tagData.slug !== existingTag.slug) {
      await cacheService.del(`tags:slug:${tagData.slug}`);
    }
    await cacheService.delByPattern('tags:list:*');
    
    res.json(success(updatedTag, '标签更新成功'));
  } catch (err) {
    next(err);
  }
};

/**
 * 删除标签（管理员功能）
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @param {Function} next - 下一个中间件
 */
exports.deleteTag = async (req, res, next) => {
  try {
    const { id } = req.params;
    
    // 检查标签是否存在
    const existingTag = await tagService.findById(id);
    
    if (!existingTag) {
      return res.status(404).json(error('标签不存在', 404));
    }
    
    // 删除标签
    await tagService.delete(id);
    
    // 清除相关缓存
    await cacheService.del(`tags:${id}`);
    await cacheService.del(`tags:slug:${existingTag.slug}`);
    await cacheService.delByPattern('tags:list:*');
    
    res.status(204).end();
  } catch (err) {
    next(err);
  }
};

/**
 * 获取文章的标签
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @param {Function} next - 下一个中间件
 */
exports.getTagsByPost = async (req, res, next) => {
  try {
    const { postId } = req.params;
    
    // 构建缓存键
    const cacheKey = `tags:post:${postId}`;
    
    // 尝试从缓存获取，如果没有则从数据库获取并缓存
    const tags = await cacheService.getOrSet(cacheKey, async () => {
      return await tagService.getTagsByPostId(postId);
    }, 600); // 缓存10分钟
    
    res.json(success(tags, '获取文章标签成功'));
  } catch (err) {
    next(err);
  }
}; 